js和java stream对比

filter and collect

// 顺序进行
List<Apple> listStream = list.stream()
        .filter((Apple a) -> a.getWeight() >20 || "green".equals(a.getColor()))
        .collect(Collectors.toList());
//并行进行
List<Apple> listStreamc = list.parallelStream()
        .filter((Apple a) -> a.getWeight() >20 || "green".equals(a.getColor()))
        .collect(Collectors.toList());

let colors = ["red", "blue", "grey"];

colors.forEach((item, index, arr) ==> {
    if(item === "red") {
        arr.splice(index, 1);
    }
});

filter and foreach

List<Integer> list  = Arrays.asList(12, 3, 4, 5, 4);
list.stream().filter( i -> i % 2 == 0)
             .forEach(System.out::print);// 12 4 4

let users = [{ name: "毋意", value: "202201" }, { name: "毋必", value: "202202" }, 
             { name: "毋固", value: "202203" },{ name: "毋我", value: "202204" }]

users.filter(o => o.value === 202201 ).forEach(o =>console.log('out :%s',o))
//out :{ name: '毋意', value: '202201' }

map

List<Integer> list  = Arrays.asList(12, 3, 4, 5, 4);
list.stream().map(o -> o+1 ).forEach(System.out::println);

let users = [{ name: "毋意", value: "202201" }, { name: "毋必", value: "202202" }, 
             { name: "毋固", value: "202203" },{ name: "毋我", value: "202204" }]             
users.map( o => o.name ).forEach(o =>console.log('out :%s',o))

flatMap

List<String> strings = Arrays.asList("Hello","World");
strings.stream().map(o -> o.split(""))
        .flatMap(Arrays::stream)
        .forEach(System.out::println);

let string = ["Hello","World"]
string.flatMap( o => o.split("")).forEach(o =>console.log('out :%s',o))

JS提供了flat方法可以默认展开数组,flat() 方法会按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。

[1, 2, [3, [4, 5]]].flat()
// [1, 2, 3, [4, 5]]

[1, 2, [3, [4, 5]]].flat(2)
// [1, 2, 3, 4, 5]

截断

通过截断流我们可以看到Java的JavaScript在Stream上本质的不同，Java通过Stream 对象本身OP_MASK属性来截断,而JS没有实际意义上的Stream对象， 但是可以通过filter结合index来完成，或者使用slice

List<Integer> list  = Arrays.asList(12, 3, 4, 5, 4);
list.stream().limit(2).forEach(System.out::println);

let users = [{ name: "毋意", value: "202201" }, { name: "毋必", value: "202202" }, 
             { name: "毋固", value: "202203" },{ name: "毋我", value: "202204" }]   
users.slice(2).forEach(o =>console.log('out :%s',o))

//user.slice(2) 表示只保留前2个元素
======================================
out :{ name: '毋意', value: '202201' }
out :{ name: '毋必', value: '202202' }

users.filter((_, i) => i < 2).forEach(o => console.log('out :%s', o))
============
out :{ name: '毋意', value: '202201' }
out :{ name: '毋必', value: '202202' }

排序

List<Integer> list  = Arrays.asList(12, 3, 4, 5, 4);
list.stream()
        .sorted( (o1,o2) -> o1 > o2 ? 1 : (o1 < o2 ? -1 : 0 ))
        .forEach(System.out::println);

let users = [{ name: "毋意", value: "202201" }, { name: "毋必", value: "202202" }, 
             { name: "毋固", value: "202203" },{ name: "毋我", value: "202204" }]  
users.map(o => { return { name: o.name, value: +o.value } })
     .sort((o1, o2) => o1.value > o2.value ? -1 : (o1.value < o2.value ? 1 : 0))
     .forEach(o => console.log(o))
==================================
{ name: '毋我', value: 202204 }
{ name: '毋固', value: 202203 }
{ name: '毋必', value: 202202 }
{ name: '毋意', value: 202201 }

去重

List<Integer> list  = Arrays.asList(12, 3, 4, 5, 4);
list.stream().distinct().forEach(System.out::println);

let numbers = [2,3,4,3,5,2]
Array.from(new Set(numbers)).forEach(o => console.log(o))

跳过

跳过元素：返回一个扔掉了前n个元素的流。如果流中元素不足n个，则返回一个空流。

List<Integer> list  = Arrays.asList(12, 3, 4, 5, 4);
list.stream().skip(2).forEach(System.out::println);
==================
4
5
4

let users = [{ name: "毋意", value: "202201" }, { name: "毋必", value: "202202" }, 
             { name: "毋固", value: "202203" },{ name: "毋我", value: "202204" }] 
users.slice(0, 2).forEach(o => console.log(o))             
=========
{ name: '毋固', value: '202203' }
{ name: '毋我', value: '202204' }

group

分组操作的结果是一个Map，把分组函数返回的值作为映射的键，把流中所有具有这个分类值的项目的列表作为对应的映射值

List<String> lists  = Arrays.asList("123", "1234", "4564", "789");
lists.stream().collect(Collectors.groupingBy( o -> o.length()))
              .forEach((o1,o2) -> System.out.printf("%s:%s\\n",o1,o2));
=========
3:[123, 789]
4:[1234, 4564]

const array = [1, 2, 3, 4, 5];

array.group((num, index, array) => {
  return num % 2 === 0 ? 'even': 'odd';
});
// { odd: [1, 3, 5], even: [2, 4] }

groupToMap()的作用和用法与group()完全一致，唯一的区别是返回值是一个Map 结构，而不是对象

const array = [1, 2, 3, 4, 5];

const odd  = { odd: true };
const even = { even: true };
array.groupToMap((num, index, array) => {
  return num % 2 === 0 ? even: odd;
});
//  Map { {odd: true}: [1, 3, 5], {even: true}: [2, 4] }

查找

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
System.out.println(numbers.stream().findAny().get()); //1
System.out.println(numbers.stream().findFirst().get()); //1

let users = [{ name: "毋意", value: "202201" }, { name: "毋必", value: "202202" },
{ name: "毋固", value: "202203" }, { name: "毋我", value: "202204" }]

let user = users.find(o => o.name === "毋固")
console.log(user) //{ name: '毋固', value: '202203' }
let useri = users.findIndex(o => o.name === "毋固")
console.log(useri) //2

参考

关于Java&JavaScript中(伪)Stream式API对比的一些笔记